home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Lib / tkinter / Tkinter.py < prev   
Text File  |  1996-02-28  |  46KB  |  1,411 lines
  1. # Tkinter.py -- Tk/Tcl widget wrappers
  2.  
  3. try:
  4.     import _tkinter
  5.     tkinter = _tkinter # b/w compat
  6. except ImportError:
  7.     import tkinter
  8. TclError = tkinter.TclError
  9. from types import *
  10. from Tkconstants import *
  11.  
  12. TkVersion = eval(tkinter.TK_VERSION)
  13. TclVersion = eval(tkinter.TCL_VERSION)
  14.  
  15.  
  16. def _flatten(tuple):
  17.     res = ()
  18.     for item in tuple:
  19.         if type(item) in (TupleType, ListType):
  20.             res = res + _flatten(item)
  21.         elif item is not None:
  22.             res = res + (item,)
  23.     return res
  24.  
  25. def _cnfmerge(cnfs):
  26.     if type(cnfs) is DictionaryType:
  27.         return cnfs
  28.     elif type(cnfs) in (NoneType, StringType):
  29.         
  30.         return cnfs
  31.     else:
  32.         cnf = {}
  33.         for c in _flatten(cnfs):
  34.             for k, v in c.items():
  35.                 cnf[k] = v
  36.         return cnf
  37.  
  38. class Event:
  39.     pass
  40.  
  41. _default_root = None
  42.  
  43. def _tkerror(err):
  44.     pass
  45.  
  46. def _exit(code='0'):
  47.     import sys
  48.     sys.exit(getint(code))
  49.  
  50. _varnum = 0
  51. class Variable:
  52.     def __init__(self, master=None):
  53.         global _default_root
  54.         global _varnum
  55.         if master:
  56.             self._tk = master.tk
  57.         else:
  58.             self._tk = _default_root.tk
  59.         self._name = 'PY_VAR' + `_varnum`
  60.         _varnum = _varnum + 1
  61.     def __del__(self):
  62.         self._tk.unsetvar(self._name)
  63.     def __str__(self):
  64.         return self._name
  65.     def set(self, value):
  66.         return self._tk.setvar(self._name, value)
  67.  
  68. class StringVar(Variable):
  69.     def __init__(self, master=None):
  70.         Variable.__init__(self, master)
  71.     def get(self):
  72.         return self._tk.getvar(self._name)
  73.  
  74. class IntVar(Variable):
  75.     def __init__(self, master=None):
  76.         Variable.__init__(self, master)
  77.     def get(self):
  78.         return self._tk.getint(self._tk.getvar(self._name))
  79.  
  80. class DoubleVar(Variable):
  81.     def __init__(self, master=None):
  82.         Variable.__init__(self, master)
  83.     def get(self):
  84.         return self._tk.getdouble(self._tk.getvar(self._name))
  85.  
  86. class BooleanVar(Variable):
  87.     def __init__(self, master=None):
  88.         Variable.__init__(self, master)
  89.     def get(self):
  90.         return self._tk.getboolean(self._tk.getvar(self._name))
  91.  
  92. def mainloop(n=0):
  93.     _default_root.tk.mainloop(n)
  94.  
  95. def getint(s):
  96.     return _default_root.tk.getint(s)
  97.  
  98. def getdouble(s):
  99.     return _default_root.tk.getdouble(s)
  100.  
  101. def getboolean(s):
  102.     return _default_root.tk.getboolean(s)
  103.  
  104. class Misc:
  105.     def tk_strictMotif(self, boolean=None):
  106.         return self.tk.getboolean(self.tk.call(
  107.             'set', 'tk_strictMotif', boolean))
  108.     def tk_menuBar(self, *args):
  109.         apply(self.tk.call, ('tk_menuBar', self._w) + args)
  110.     def wait_variable(self, name='PY_VAR'):
  111.         self.tk.call('tkwait', 'variable', name)
  112.     waitvar = wait_variable # XXX b/w compat
  113.     def wait_window(self, window=None):
  114.         if window == None:
  115.             window = self
  116.         self.tk.call('tkwait', 'window', window._w)
  117.     def wait_visibility(self, window=None):
  118.         if window == None:
  119.             window = self
  120.         self.tk.call('tkwait', 'visibility', window._w)
  121.     def setvar(self, name='PY_VAR', value='1'):
  122.         self.tk.setvar(name, value)
  123.     def getvar(self, name='PY_VAR'):
  124.         return self.tk.getvar(name)
  125.     def getint(self, s):
  126.         return self.tk.getint(s)
  127.     def getdouble(self, s):
  128.         return self.tk.getdouble(s)
  129.     def getboolean(self, s):
  130.         return self.tk.getboolean(s)
  131.     def focus_set(self):
  132.         self.tk.call('focus', self._w)
  133.     focus = focus_set # XXX b/w compat?
  134.     def focus_default_set(self):
  135.         self.tk.call('focus', 'default', self._w)
  136.     def focus_default_none(self):
  137.         self.tk.call('focus', 'default', 'none')
  138.     focus_default = focus_default_set
  139.     def focus_none(self):
  140.         self.tk.call('focus', 'none')
  141.     def focus_get(self):
  142.         name = self.tk.call('focus')
  143.         if name == 'none': return None
  144.         return self._nametowidget(name)
  145.     def after(self, ms, func=None, *args):
  146.         if not func:
  147.             # I'd rather use time.sleep(ms*0.001)
  148.             self.tk.call('after', ms)
  149.         else:
  150.             # XXX Disgusting hack to clean up after calling func
  151.             tmp = []
  152.             def callit(func=func, args=args, tk=self.tk, tmp=tmp):
  153.                 try:
  154.                     apply(func, args)
  155.                 finally:
  156.                     tk.deletecommand(tmp[0])
  157.             name = self._register(callit)
  158.             tmp.append(name)
  159.             return self.tk.call('after', ms, name)
  160.     def after_idle(self, func, *args):
  161.         return apply(self.after, ('idle', func) + args)
  162.     def after_cancel(self, id):
  163.         self.tk.call('after', 'cancel', id)
  164.     def bell(self, displayof=None):
  165.         if displayof:
  166.             self.tk.call('bell', '-displayof', displayof)
  167.         else:
  168.             self.tk.call('bell', '-displayof', self._w)
  169.     # XXX grab current w/o window argument
  170.     def grab_current(self):
  171.         name = self.tk.call('grab', 'current', self._w)
  172.         if not name: return None
  173.         return self._nametowidget(name)
  174.     def grab_release(self):
  175.         self.tk.call('grab', 'release', self._w)
  176.     def grab_set(self):
  177.         self.tk.call('grab', 'set', self._w)
  178.     def grab_set_global(self):
  179.         self.tk.call('grab', 'set', '-global', self._w)
  180.     def grab_status(self):
  181.         status = self.tk.call('grab', 'status', self._w)
  182.         if status == 'none': status = None
  183.         return status
  184.     def lower(self, belowThis=None):
  185.         self.tk.call('lower', self._w, belowThis)
  186.     def option_add(self, pattern, value, priority = None):
  187.         self.tk.call('option', 'add', pattern, value, priority)
  188.     def option_clear(self):
  189.         self.tk.call('option', 'clear')
  190.     def option_get(self, name, className):
  191.         return self.tk.call('option', 'get', self._w, name, className)
  192.     def option_readfile(self, fileName, priority = None):
  193.         self.tk.call('option', 'readfile', fileName, priority)
  194.     def selection_clear(self):
  195.         self.tk.call('selection', 'clear', self._w)
  196.     def selection_get(self, type=None):
  197.         return self.tk.call('selection', 'get', type)
  198.     def selection_handle(self, func, type=None, format=None):
  199.         name = self._register(func)
  200.         self.tk.call('selection', 'handle', self._w, 
  201.                  name, type, format)
  202.     def selection_own(self, func=None):
  203.         name = self._register(func)
  204.         self.tk.call('selection', 'own', self._w, name)
  205.     def selection_own_get(self):
  206.         return self._nametowidget(self.tk.call('selection', 'own'))
  207.     def send(self, interp, cmd, *args):
  208.         return apply(self.tk.call, ('send', interp, cmd) + args)
  209.     def lower(self, belowThis=None):
  210.         self.tk.call('lift', self._w, belowThis)
  211.     def tkraise(self, aboveThis=None):
  212.         self.tk.call('raise', self._w, aboveThis)
  213.     lift = tkraise
  214.     def colormodel(self, value=None):
  215.         return self.tk.call('tk', 'colormodel', self._w, value)
  216.     def winfo_atom(self, name):
  217.         return self.tk.getint(self.tk.call('winfo', 'atom', name))
  218.     def winfo_atomname(self, id):
  219.         return self.tk.call('winfo', 'atomname', id)
  220.     def winfo_cells(self):
  221.         return self.tk.getint(
  222.             self.tk.call('winfo', 'cells', self._w))
  223.     def winfo_children(self):
  224.         return map(self._nametowidget,
  225.                self.tk.splitlist(self.tk.call(
  226.                    'winfo', 'children', self._w)))
  227.     def winfo_class(self):
  228.         return self.tk.call('winfo', 'class', self._w)
  229.     def winfo_containing(self, rootX, rootY):
  230.         return self.tk.call('winfo', 'containing', rootx, rootY)
  231.     def winfo_depth(self):
  232.         return self.tk.getint(self.tk.call('winfo', 'depth', self._w))
  233.     def winfo_exists(self):
  234.         return self.tk.getint(
  235.             self.tk.call('winfo', 'exists', self._w))
  236.     def winfo_fpixels(self, number):
  237.         return self.tk.getdouble(self.tk.call(
  238.             'winfo', 'fpixels', self._w, number))
  239.     def winfo_geometry(self):
  240.         return self.tk.call('winfo', 'geometry', self._w)
  241.     def winfo_height(self):
  242.         return self.tk.getint(
  243.             self.tk.call('winfo', 'height', self._w))
  244.     def winfo_id(self):
  245.         return self.tk.getint(
  246.             self.tk.call('winfo', 'id', self._w))
  247.     def winfo_interps(self):
  248.         return self.tk.splitlist(
  249.             self.tk.call('winfo', 'interps'))
  250.     def winfo_ismapped(self):
  251.         return self.tk.getint(
  252.             self.tk.call('winfo', 'ismapped', self._w))
  253.     def winfo_name(self):
  254.         return self.tk.call('winfo', 'name', self._w)
  255.     def winfo_parent(self):
  256.         return self.tk.call('winfo', 'parent', self._w)
  257.     def winfo_pathname(self, id):
  258.         return self.tk.call('winfo', 'pathname', id)
  259.     def winfo_pixels(self, number):
  260.         return self.tk.getint(
  261.             self.tk.call('winfo', 'pixels', self._w, number))
  262.     def winfo_reqheight(self):
  263.         return self.tk.getint(
  264.             self.tk.call('winfo', 'reqheight', self._w))
  265.     def winfo_reqwidth(self):
  266.         return self.tk.getint(
  267.             self.tk.call('winfo', 'reqwidth', self._w))
  268.     def winfo_rgb(self, color):
  269.         return self._getints(
  270.             self.tk.call('winfo', 'rgb', self._w, color))
  271.     def winfo_rootx(self):
  272.         return self.tk.getint(
  273.             self.tk.call('winfo', 'rootx', self._w))
  274.     def winfo_rooty(self):
  275.         return self.tk.getint(
  276.             self.tk.call('winfo', 'rooty', self._w))
  277.     def winfo_screen(self):
  278.         return self.tk.call('winfo', 'screen', self._w)
  279.     def winfo_screencells(self):
  280.         return self.tk.getint(
  281.             self.tk.call('winfo', 'screencells', self._w))
  282.     def winfo_screendepth(self):
  283.         return self.tk.getint(
  284.             self.tk.call('winfo', 'screendepth', self._w))
  285.     def winfo_screenheight(self):
  286.         return self.tk.getint(
  287.             self.tk.call('winfo', 'screenheight', self._w))
  288.     def winfo_screenmmheight(self):
  289.         return self.tk.getint(
  290.             self.tk.call('winfo', 'screenmmheight', self._w))
  291.     def winfo_screenmmwidth(self):
  292.         return self.tk.getint(
  293.             self.tk.call('winfo', 'screenmmwidth', self._w))
  294.     def winfo_screenvisual(self):
  295.         return self.tk.call('winfo', 'screenvisual', self._w)
  296.     def winfo_screenwidth(self):
  297.         return self.tk.getint(
  298.             self.tk.call('winfo', 'screenwidth', self._w))
  299.     def winfo_toplevel(self):
  300.         return self._nametowidget(self.tk.call(
  301.             'winfo', 'toplevel', self._w))
  302.     def winfo_visual(self):
  303.         return self.tk.call('winfo', 'visual', self._w)
  304.     def winfo_vrootheight(self):
  305.         return self.tk.getint(
  306.             self.tk.call('winfo', 'vrootheight', self._w))
  307.     def winfo_vrootwidth(self):
  308.         return self.tk.getint(
  309.             self.tk.call('winfo', 'vrootwidth', self._w))
  310.     def winfo_vrootx(self):
  311.         return self.tk.getint(
  312.             self.tk.call('winfo', 'vrootx', self._w))
  313.     def winfo_vrooty(self):
  314.         return self.tk.getint(
  315.             self.tk.call('winfo', 'vrooty', self._w))
  316.     def winfo_width(self):
  317.         return self.tk.getint(
  318.             self.tk.call('winfo', 'width', self._w))
  319.     def winfo_x(self):
  320.         return self.tk.getint(
  321.             self.tk.call('winfo', 'x', self._w))
  322.     def winfo_y(self):
  323.         return self.tk.getint(
  324.             self.tk.call('winfo', 'y', self._w))
  325.     def update(self):
  326.         self.tk.call('update')
  327.     def update_idletasks(self):
  328.         self.tk.call('update', 'idletasks')
  329.     def bindtags(self, tagList=None):
  330.         if tagList is None:
  331.             return splitlist(self.tk.call('bindtags', self._w))
  332.         else:
  333.             self.tk.call('bindtags', self._w, tagList)
  334.     def bind(self, sequence=None, func=None, add='', brk=''):
  335.         if add: add = '+'
  336.         if func:
  337.             name = self._register(func, self._substitute)
  338.             self.tk.call('bind', self._w, sequence, 
  339.                      (add + name,) + self._subst_format)
  340.             if brk:
  341.                 self.tk.call('bind', self._w, sequence,
  342.                          "+break")
  343.         else:
  344.             return self.tk.call('bind', self._w, sequence)
  345.     def unbind(self, sequence):
  346.         self.tk.call('bind', self._w, sequence, '')
  347.     def bind_all(self, sequence=None, func=None, add='', brk=''):
  348.         if add: add = '+'
  349.         if func:
  350.             name = self._register(func, self._substitute)
  351.             self.tk.call('bind', 'all' , sequence, 
  352.                      (add + name,) + self._subst_format)
  353.             if brk:
  354.                 self.tk.call('bind', self._w, sequence,
  355.                          "+break")
  356.         else:
  357.             return self.tk.call('bind', 'all', sequence)
  358.     def unbind_all(self, sequence):
  359.         self.tk.call('bind', 'all' , sequence, '')
  360.     def bind_class(self, className, sequence=None,
  361.                func=None, add='', brk=''):
  362.         if add: add = '+'
  363.         if func:
  364.             name = self._register(func, self._substitute)
  365.             self.tk.call('bind', className , sequence, 
  366.                      (add + name,) + self._subst_format)
  367.             if brk:
  368.                 self.tk.call('bind', self._w, sequence,
  369.                          "+break")
  370.         else:
  371.             return self.tk.call('bind', className, sequence)
  372.     def unbind_class(self, className, sequence):
  373.         self.tk.call('bind', className , sequence, '')
  374.     def mainloop(self, n=0):
  375.         self.tk.mainloop(n)
  376.     def quit(self):
  377.         self.tk.quit()
  378.     def _getints(self, string):
  379.         if not string: return None
  380.         return tuple(map(self.tk.getint, self.tk.splitlist(string)))
  381.     def _getdoubles(self, string):
  382.         if not string: return None
  383.         return tuple(map(self.tk.getdouble, self.tk.splitlist(string)))
  384.     def _getboolean(self, string):
  385.         if string:
  386.             return self.tk.getboolean(string)
  387.     def _options(self, cnf, kw = None):
  388.         if kw:
  389.             cnf = _cnfmerge((cnf, kw))
  390.         else:
  391.             cnf = _cnfmerge(cnf)
  392.         res = ()
  393.         for k, v in cnf.items():
  394.             if k[-1] == '_': k = k[:-1]
  395.             if callable(v):
  396.                 v = self._register(v)
  397.             res = res + ('-'+k, v)
  398.         return res
  399.     def _nametowidget(self, name):
  400.         w = self
  401.         if name[0] == '.':
  402.             w = w._root()
  403.             name = name[1:]
  404.         from string import find
  405.         while name:
  406.             i = find(name, '.')
  407.             if i >= 0:
  408.                 name, tail = name[:i], name[i+1:]
  409.             else:
  410.                 tail = ''
  411.             w = w.children[name]
  412.             name = tail
  413.         return w
  414.     def _register(self, func, subst=None):
  415.         f = self._wrap(func, subst)
  416.         name = `id(f)`
  417.         if hasattr(func, 'im_func'):
  418.             func = func.im_func
  419.         if hasattr(func, '__name__') and \
  420.            type(func.__name__) == type(''):
  421.             name = name + func.__name__
  422.         self.tk.createcommand(name, f)
  423.         return name
  424.     register = _register
  425.     def _root(self):
  426.         w = self
  427.         while w.master: w = w.master
  428.         return w
  429.     _subst_format = ('%#', '%b', '%f', '%h', '%k', 
  430.              '%s', '%t', '%w', '%x', '%y',
  431.              '%A', '%E', '%K', '%N', '%W', '%T', '%X', '%Y')
  432.     def _substitute(self, *args):
  433.         tk = self.tk
  434.         if len(args) != len(self._subst_format): return args
  435.         nsign, b, f, h, k, s, t, w, x, y, A, E, K, N, W, T, X, Y = args
  436.         # Missing: (a, c, d, m, o, v, B, R)
  437.         e = Event()
  438.         e.serial = tk.getint(nsign)
  439.         e.num = tk.getint(b)
  440.         try: e.focus = tk.getboolean(f)
  441.         except TclError: pass
  442.         e.height = tk.getint(h)
  443.         e.keycode = tk.getint(k)
  444.         e.state = tk.getint(s)
  445.         e.time = tk.getint(t)
  446.         e.width = tk.getint(w)
  447.         e.x = tk.getint(x)
  448.         e.y = tk.getint(y)
  449.         e.char = A
  450.         try: e.send_event = tk.getboolean(E)
  451.         except TclError: pass
  452.         e.keysym = K
  453.         e.keysym_num = tk.getint(N)
  454.         e.type = T
  455.         e.widget = self._nametowidget(W)
  456.         e.x_root = tk.getint(X)
  457.         e.y_root = tk.getint(Y)
  458.         return (e,)
  459.     def _report_exception(self):
  460.         import sys
  461.         exc, val, tb = sys.exc_type, sys.exc_value, sys.exc_traceback
  462.         root = self._root()
  463.         root.report_callback_exception(exc, val, tb)
  464.     def _wrap(self, func, subst=None):
  465.         return CallWrapper(func, subst, self).__call__
  466.  
  467. class CallWrapper:
  468.     def __init__(self, func, subst, widget):
  469.         self.func = func
  470.         self.subst = subst
  471.         self.widget = widget
  472.     def __call__(self, *args):
  473.         try:
  474.             if self.subst:
  475.                 args = apply(self.subst, args)
  476.             return apply(self.func, args)
  477.         except SystemExit, msg:
  478.             raise SystemExit, msg
  479.         except:
  480.             self.widget._report_exception()
  481.  
  482. class Wm:
  483.     def aspect(self, 
  484.            minNumer=None, minDenom=None, 
  485.            maxNumer=None, maxDenom=None):
  486.         return self._getints(
  487.             self.tk.call('wm', 'aspect', self._w, 
  488.                      minNumer, minDenom, 
  489.                      maxNumer, maxDenom))
  490.     def client(self, name=None):
  491.         return self.tk.call('wm', 'client', self._w, name)
  492.     def command(self, value=None):
  493.         return self.tk.call('wm', 'command', self._w, value)
  494.     def deiconify(self):
  495.         return self.tk.call('wm', 'deiconify', self._w)
  496.     def focusmodel(self, model=None):
  497.         return self.tk.call('wm', 'focusmodel', self._w, model)
  498.     def frame(self):
  499.         return self.tk.call('wm', 'frame', self._w)
  500.     def geometry(self, newGeometry=None):
  501.         return self.tk.call('wm', 'geometry', self._w, newGeometry)
  502.     def grid(self,
  503.          baseWidht=None, baseHeight=None, 
  504.          widthInc=None, heightInc=None):
  505.         return self._getints(self.tk.call(
  506.             'wm', 'grid', self._w,
  507.             baseWidht, baseHeight, widthInc, heightInc))
  508.     def group(self, pathName=None):
  509.         return self.tk.call('wm', 'group', self._w, pathName)
  510.     def iconbitmap(self, bitmap=None):
  511.         return self.tk.call('wm', 'iconbitmap', self._w, bitmap)
  512.     def iconify(self):
  513.         return self.tk.call('wm', 'iconify', self._w)
  514.     def iconmask(self, bitmap=None):
  515.         return self.tk.call('wm', 'iconmask', self._w, bitmap)
  516.     def iconname(self, newName=None):
  517.         return self.tk.call('wm', 'iconname', self._w, newName)
  518.     def iconposition(self, x=None, y=None):
  519.         return self._getints(self.tk.call(
  520.             'wm', 'iconposition', self._w, x, y))
  521.     def iconwindow(self, pathName=None):
  522.         return self.tk.call('wm', 'iconwindow', self._w, pathName)
  523.     def maxsize(self, width=None, height=None):
  524.         return self._getints(self.tk.call(
  525.             'wm', 'maxsize', self._w, width, height))
  526.     def minsize(self, width=None, height=None):
  527.         return self._getints(self.tk.call(
  528.             'wm', 'minsize', self._w, width, height))
  529.     def overrideredirect(self, boolean=None):
  530.         return self._getboolean(self.tk.call(
  531.             'wm', 'overrideredirect', self._w, boolean))
  532.     def positionfrom(self, who=None):
  533.         return self.tk.call('wm', 'positionfrom', self._w, who)
  534.     def protocol(self, name=None, func=None):
  535.             if callable(func):
  536.             command = self._register(func)
  537.         else:
  538.             command = func
  539.         return self.tk.call(
  540.             'wm', 'protocol', self._w, name, command)
  541.     def resizable(self, width=None, height=None):
  542.         return self.tk.call('wm', 'resizable', self._w, width, height)
  543.     def sizefrom(self, who=None):
  544.         return self.tk.call('wm', 'sizefrom', self._w, who)
  545.     def state(self):
  546.         return self.tk.call('wm', 'state', self._w)
  547.     def title(self, string=None):
  548.         return self.tk.call('wm', 'title', self._w, string)
  549.     def transient(self, master=None):
  550.         return self.tk.call('wm', 'transient', self._w, master)
  551.     def withdraw(self):
  552.         return self.tk.call('wm', 'withdraw', self._w)
  553.  
  554. class Tk(Misc, Wm):
  555.     _w = '.'
  556.     def __init__(self, screenName=None, baseName=None, className='Tk'):
  557.         global _default_root
  558.         self.master = None
  559.         self.children = {}
  560.         if baseName is None:
  561.             import sys, os
  562.             baseName = os.path.basename(sys.argv[0])
  563.             if baseName[-3:] == '.py': baseName = baseName[:-3]
  564.         self.tk = tkinter.create(screenName, baseName, className)
  565.         try:
  566.             # Disable event scanning except for Command-Period
  567.             import MacOS
  568.             MacOS.EnableAppswitch(0)
  569.         except ImportError:
  570.             pass
  571.         else:
  572.             # Work-around for nasty bug in Tk
  573.             self.update()
  574.         # Version sanity checks
  575.         tk_version = self.tk.getvar('tk_version')
  576.         if tk_version != tkinter.TK_VERSION:
  577.             raise RuntimeError, \
  578.             "tk.h version (%s) doesn't match libtk.a version (%s)" \
  579.             % (tkinter.TK_VERSION, tk_version)
  580.         tcl_version = self.tk.getvar('tcl_version')
  581.         if tcl_version != tkinter.TCL_VERSION:
  582.             raise RuntimeError, \
  583.             "tcl.h version (%s) doesn't match libtcl.a version (%s)" \
  584.             % (tkinter.TCL_VERSION, tcl_version)
  585.         if TkVersion < 4.0:
  586.             raise RuntimeError, \
  587.             "Tk 4.0 or higher is required; found Tk %s" \
  588.             % str(TkVersion)
  589.         self.tk.createcommand('tkerror', _tkerror)
  590.         self.tk.createcommand('exit', _exit)
  591.         self.readprofile(baseName, className)
  592.         if not _default_root:
  593.             _default_root = self
  594.     def destroy(self):
  595.         for c in self.children.values(): c.destroy()
  596.         self.tk.call('destroy', self._w)
  597.     def __str__(self):
  598.         return self._w
  599.     def readprofile(self, baseName, className):
  600.         ##print __import__
  601.         import os, pdb
  602.         if os.environ.has_key('HOME'): home = os.environ['HOME']
  603.         else: home = os.curdir
  604.         class_tcl = os.path.join(home, '.%s.tcl' % className)
  605.         class_py = os.path.join(home, '.%s.py' % className)
  606.         base_tcl = os.path.join(home, '.%s.tcl' % baseName)
  607.         base_py = os.path.join(home, '.%s.py' % baseName)
  608.         dir = {'self': self}
  609.         ##pdb.run('from Tkinter import *', dir)
  610.         exec 'from Tkinter import *' in dir
  611.         if os.path.isfile(class_tcl):
  612.             print 'source', `class_tcl`
  613.             self.tk.call('source', class_tcl)
  614.         if os.path.isfile(class_py):
  615.             print 'execfile', `class_py`
  616.             execfile(class_py, dir)
  617.         if os.path.isfile(base_tcl):
  618.             print 'source', `base_tcl`
  619.             self.tk.call('source', base_tcl)
  620.         if os.path.isfile(base_py):
  621.             print 'execfile', `base_py`
  622.             execfile(base_py, dir)
  623.     def report_callback_exception(self, exc, val, tb):
  624.         import traceback
  625.         print "Exception in Tkinter callback"
  626.         traceback.print_exception(exc, val, tb)
  627.  
  628. class Pack:
  629.     def config(self, cnf={}, **kw):
  630.         apply(self.tk.call, 
  631.               ('pack', 'configure', self._w) 
  632.               + self._options(cnf, kw))
  633.     pack = config
  634.     def __setitem__(self, key, value):
  635.         Pack.config({key: value})
  636.     def forget(self):
  637.         self.tk.call('pack', 'forget', self._w)
  638.     def newinfo(self):
  639.         words = self.tk.splitlist(
  640.             self.tk.call('pack', 'newinfo', self._w))
  641.         dict = {}
  642.         for i in range(0, len(words), 2):
  643.             key = words[i][1:]
  644.             value = words[i+1]
  645.             if value[0] == '.':
  646.                 value = self._nametowidget(value)
  647.             dict[key] = value
  648.         return dict
  649.     info = newinfo
  650.     _noarg_ = ['_noarg_']
  651.     def propagate(self, flag=_noarg_):
  652.         if flag is Pack._noarg_:
  653.             return self._getboolean(self.tk.call(
  654.                 'pack', 'propagate', self._w))
  655.         else:
  656.             self.tk.call('pack', 'propagate', self._w, flag)
  657.     def slaves(self):
  658.         return map(self._nametowidget,
  659.                self.tk.splitlist(
  660.                    self.tk.call('pack', 'slaves', self._w)))
  661.  
  662. class Place:
  663.     def config(self, cnf={}, **kw):
  664.         apply(self.tk.call, 
  665.               ('place', 'configure', self._w) 
  666.               + self._options(cnf, kw))
  667.     place = config
  668.     def __setitem__(self, key, value):
  669.         Place.config({key: value})
  670.     def forget(self):
  671.         self.tk.call('place', 'forget', self._w)
  672.     def info(self):
  673.         return self.tk.call('place', 'info', self._w)
  674.     def slaves(self):
  675.         return map(self._nametowidget,
  676.                self.tk.splitlist(
  677.                    self.tk.call(
  678.                        'place', 'slaves', self._w)))
  679.  
  680. class Widget(Misc, Pack, Place):
  681.     def _setup(self, master, cnf):
  682.         global _default_root
  683.         if not master:
  684.             if not _default_root:
  685.                 _default_root = Tk()
  686.             master = _default_root
  687.         if not _default_root:
  688.             _default_root = master
  689.         self.master = master
  690.         self.tk = master.tk
  691.         if cnf.has_key('name'):
  692.             name = cnf['name']
  693.             del cnf['name']
  694.         else:
  695.             name = `id(self)`
  696.         self._name = name
  697.         if master._w=='.':
  698.             self._w = '.' + name
  699.         else:
  700.             self._w = master._w + '.' + name
  701.         self.children = {}
  702.         if self.master.children.has_key(self._name):
  703.             self.master.children[self._name].destroy()
  704.         self.master.children[self._name] = self
  705.     def __init__(self, master, widgetName, cnf={}, kw={}, extra=()):
  706.         if kw:
  707.             cnf = _cnfmerge((cnf, kw))
  708.         self.widgetName = widgetName
  709.         Widget._setup(self, master, cnf)
  710.         apply(self.tk.call, (widgetName, self._w)+extra)
  711.         if cnf:
  712.             Widget.config(self, cnf)
  713.     def config(self, cnf=None, **kw):
  714.         # XXX ought to generalize this so tag_config etc. can use it
  715.         if kw:
  716.             cnf = _cnfmerge((cnf, kw))
  717.         else:
  718.             cnf = _cnfmerge(cnf)
  719.         if cnf is None:
  720.             cnf = {}
  721.             for x in self.tk.split(
  722.                 self.tk.call(self._w, 'configure')):
  723.                 cnf[x[0][1:]] = (x[0][1:],) + x[1:]
  724.             return cnf
  725.         if type(cnf) == StringType:
  726.             x = self.tk.split(self.tk.call(
  727.                 self._w, 'configure', '-'+cnf))
  728.             return (x[0][1:],) + x[1:]
  729.         for k in cnf.keys():
  730.             if type(k) == ClassType:
  731.                 k.config(self, cnf[k])
  732.                 del cnf[k]
  733.         apply(self.tk.call, (self._w, 'configure')
  734.               + self._options(cnf))
  735.     def __getitem__(self, key):
  736.         return self.tk.call(self._w, 'cget', '-' + key)
  737.     def __setitem__(self, key, value):
  738.         Widget.config(self, {key: value})
  739.     def keys(self):
  740.         return map(lambda x: x[0][1:],
  741.                self.tk.split(self.tk.call(self._w, 'configure')))
  742.     def __str__(self):
  743.         return self._w
  744.     def destroy(self):
  745.         for c in self.children.values(): c.destroy()
  746.         if self.master.children.has_key(self._name):
  747.             del self.master.children[self._name]
  748.         self.tk.call('destroy', self._w)
  749.     def _do(self, name, args=()):
  750.         return apply(self.tk.call, (self._w, name) + args)
  751.  
  752. class Toplevel(Widget, Wm):
  753.     def __init__(self, master=None, cnf={}, **kw):
  754.         if kw:
  755.             cnf = _cnfmerge((cnf, kw))
  756.         extra = ()
  757.         for wmkey in ['screen', 'class_', 'class', 'visual',
  758.                   'colormap']:
  759.             if cnf.has_key(wmkey):
  760.                 val = cnf[wmkey]
  761.                 # TBD: a hack needed because some keys
  762.                 # are not valid as keyword arguments
  763.                 if wmkey[-1] == '_': opt = '-'+wmkey[:-1]
  764.                 else: opt = '-'+wmkey
  765.                 extra = extra + (opt, val)
  766.                 del cnf[wmkey]
  767.         Widget.__init__(self, master, 'toplevel', cnf, {}, extra)
  768.         root = self._root()
  769.         self.iconname(root.iconname())
  770.         self.title(root.title())
  771.  
  772. class Button(Widget):
  773.     def __init__(self, master=None, cnf={}, **kw):
  774.         Widget.__init__(self, master, 'button', cnf, kw)
  775.     def tkButtonEnter(self, *dummy):
  776.         self.tk.call('tkButtonEnter', self._w)
  777.     def tkButtonLeave(self, *dummy):
  778.         self.tk.call('tkButtonLeave', self._w)
  779.     def tkButtonDown(self, *dummy):
  780.         self.tk.call('tkButtonDown', self._w)
  781.     def tkButtonUp(self, *dummy):
  782.         self.tk.call('tkButtonUp', self._w)
  783.     def flash(self):
  784.         self.tk.call(self._w, 'flash')
  785.     def invoke(self):
  786.         self.tk.call(self._w, 'invoke')
  787.  
  788. # Indices:
  789. # XXX I don't like these -- take them away
  790. def AtEnd():
  791.     return 'end'
  792. def AtInsert(*args):
  793.     s = 'insert'
  794.     for a in args:
  795.         if a: s = s + (' ' + a)
  796.     return s
  797. def AtSelFirst():
  798.     return 'sel.first'
  799. def AtSelLast():
  800.     return 'sel.last'
  801. def At(x, y=None):
  802.     if y is None:
  803.         return '@' + `x`        
  804.     else:
  805.         return '@' + `x` + ',' + `y`
  806.  
  807. class Canvas(Widget):
  808.     def __init__(self, master=None, cnf={}, **kw):
  809.         Widget.__init__(self, master, 'canvas', cnf, kw)
  810.     def addtag(self, *args):
  811.         self._do('addtag', args)
  812.     def addtag_above(self, tagOrId):
  813.         self.addtag('above', tagOrId)
  814.     def addtag_all(self):
  815.         self.addtag('all')
  816.     def addtag_below(self, tagOrId):
  817.         self.addtag('below', tagOrId)
  818.     def addtag_closest(self, x, y, halo=None, start=None):
  819.         self.addtag('closest', x, y, halo, start)
  820.     def addtag_enclosed(self, x1, y1, x2, y2):
  821.         self.addtag('enclosed', x1, y1, x2, y2)
  822.     def addtag_overlapping(self, x1, y1, x2, y2):
  823.         self.addtag('overlapping', x1, y1, x2, y2)
  824.     def addtag_withtag(self, tagOrId):
  825.         self.addtag('withtag', tagOrId)
  826.     def bbox(self, *args):
  827.         return self._getints(self._do('bbox', args)) or None
  828.     def tag_unbind(self, tagOrId, sequence):
  829.         self.tk.call(self._w, 'bind', tagOrId, sequence, '')
  830.     def tag_bind(self, tagOrId, sequence, func, add='', brk=''):
  831.         if add: add='+'
  832.         name = self._register(func, self._substitute)
  833.         self.tk.call(self._w, 'bind', tagOrId, sequence, 
  834.                  (add + name,) + self._subst_format)
  835.         if brk:
  836.             self.tk.call(self._w, 'bind', tagOrId, sequence,
  837.                      "+break")
  838.     def canvasx(self, screenx, gridspacing=None):
  839.         return self.tk.getdouble(self.tk.call(
  840.             self._w, 'canvasx', screenx, gridspacing))
  841.     def canvasy(self, screeny, gridspacing=None):
  842.         return self.tk.getdouble(self.tk.call(
  843.             self._w, 'canvasy', screeny, gridspacing))
  844.     def coords(self, *args):
  845.         return self._do('coords', args)
  846.     def _create(self, itemType, args, kw): # Args: (value, value, ..., cnf={})
  847.         args = _flatten(args)
  848.         cnf = args[-1]
  849.         if type(cnf) in (DictionaryType, TupleType):
  850.             args = args[:-1]
  851.         else:
  852.             cnf = {}
  853.         return self.tk.getint(apply(
  854.             self.tk.call,
  855.             (self._w, 'create', itemType) 
  856.             + args + self._options(cnf, kw)))
  857.     def create_arc(self, *args, **kw):
  858.         return self._create('arc', args, kw)
  859.     def create_bitmap(self, *args, **kw):
  860.         return self._create('bitmap', args, kw)
  861.     def create_image(self, *args, **kw):
  862.         return self._create('image', args, kw)
  863.     def create_line(self, *args, **kw):
  864.         return self._create('line', args, kw)
  865.     def create_oval(self, *args, **kw):
  866.         return self._create('oval', args, kw)
  867.     def create_polygon(self, *args, **kw):
  868.         return self._create('polygon', args, kw)
  869.     def create_rectangle(self, *args, **kw):
  870.         return self._create('rectangle', args, kw)
  871.     def create_text(self, *args, **kw):
  872.         return self._create('text', args, kw)
  873.     def create_window(self, *args, **kw):
  874.         return self._create('window', args, kw)
  875.     def dchars(self, *args):
  876.         self._do('dchars', args)
  877.     def delete(self, *args):
  878.         self._do('delete', args)
  879.     def dtag(self, *args):
  880.         self._do('dtag', args)
  881.     def find(self, *args):
  882.         return self._getints(self._do('find', args)) or ()
  883.     def find_above(self, tagOrId):
  884.         return self.find('above', tagOrId)
  885.     def find_all(self):
  886.         return self.find('all')
  887.     def find_below(self, tagOrId):
  888.         return self.find('below', tagOrId)
  889.     def find_closest(self, x, y, halo=None, start=None):
  890.         return self.find('closest', x, y, halo, start)
  891.     def find_enclosed(self, x1, y1, x2, y2):
  892.         return self.find('enclosed', x1, y1, x2, y2)
  893.     def find_overlapping(self, x1, y1, x2, y2):
  894.         return self.find('overlapping', x1, y1, x2, y2)
  895.     def find_withtag(self, tagOrId):
  896.         return self.find('withtag', tagOrId)
  897.     def focus(self, *args):
  898.         return self._do('focus', args)
  899.     def gettags(self, *args):
  900.         return self.tk.splitlist(self._do('gettags', args))
  901.     def icursor(self, *args):
  902.         self._do('icursor', args)
  903.     def index(self, *args):
  904.         return self.tk.getint(self._do('index', args))
  905.     def insert(self, *args):
  906.         self._do('insert', args)
  907.     def itemcget(self, tagOrId, option):
  908.         return self._do('itemcget', (tagOrId, '-'+option))
  909.     def itemconfig(self, tagOrId, cnf=None, **kw):
  910.         if cnf is None and not kw:
  911.             cnf = {}
  912.             for x in self.tk.split(
  913.                 self._do('itemconfigure', (tagOrId))):
  914.                 cnf[x[0][1:]] = (x[0][1:],) + x[1:]
  915.             return cnf
  916.         if type(cnf) == StringType and not kw:
  917.             x = self.tk.split(self._do('itemconfigure',
  918.                            (tagOrId, '-'+cnf,)))
  919.             return (x[0][1:],) + x[1:]
  920.         self._do('itemconfigure', (tagOrId,)
  921.              + self._options(cnf, kw))
  922.     def lower(self, *args):
  923.         self._do('lower', args)
  924.     def move(self, *args):
  925.         self._do('move', args)
  926.     def postscript(self, cnf={}, **kw):
  927.         return self._do('postscript', self._options(cnf, kw))
  928.     def tkraise(self, *args):
  929.         self._do('raise', args)
  930.     lift = tkraise
  931.     def scale(self, *args):
  932.         self._do('scale', args)
  933.     def scan_mark(self, x, y):
  934.         self.tk.call(self._w, 'scan', 'mark', x, y)
  935.     def scan_dragto(self, x, y):
  936.         self.tk.call(self._w, 'scan', 'dragto', x, y)
  937.     def select_adjust(self, tagOrId, index):
  938.         self.tk.call(self._w, 'select', 'adjust', tagOrId, index)
  939.     def select_clear(self):
  940.         self.tk.call(self._w, 'select', 'clear', 'end')
  941.     def select_from(self, tagOrId, index):
  942.         self.tk.call(self._w, 'select', 'set', tagOrId, index)
  943.     def select_item(self):
  944.         self.tk.call(self._w, 'select', 'item')
  945.     def select_to(self, tagOrId, index):
  946.         self.tk.call(self._w, 'select', 'to', tagOrId, index)
  947.     def type(self, tagOrId):
  948.         return self.tk.call(self._w, 'type', tagOrId) or None
  949.     def xview(self, *args):
  950.         if not args:
  951.             return self._getdoubles(self.tk.call(self._w, 'xview'))
  952.         apply(self.tk.call, (self._w, 'xview')+args)
  953.     def yview(self, *args):
  954.         if not args:
  955.             return self._getdoubles(self.tk.call(self._w, 'yview'))
  956.         apply(self.tk.call, (self._w, 'yview')+args)
  957.  
  958. class Checkbutton(Widget):
  959.     def __init__(self, master=None, cnf={}, **kw):
  960.         Widget.__init__(self, master, 'checkbutton', cnf, kw)
  961.     def deselect(self):
  962.         self.tk.call(self._w, 'deselect')
  963.     def flash(self):
  964.         self.tk.call(self._w, 'flash')
  965.     def invoke(self):
  966.         self.tk.call(self._w, 'invoke')
  967.     def select(self):
  968.         self.tk.call(self._w, 'select')
  969.     def toggle(self):
  970.         self.tk.call(self._w, 'toggle')
  971.  
  972. class Entry(Widget):
  973.     def __init__(self, master=None, cnf={}, **kw):
  974.         Widget.__init__(self, master, 'entry', cnf, kw)
  975.     def delete(self, first, last=None):
  976.         self.tk.call(self._w, 'delete', first, last)
  977.     def get(self):
  978.         return self.tk.call(self._w, 'get')
  979.     def icursor(self, index):
  980.         self.tk.call(self._w, 'icursor', index)
  981.     def index(self, index):
  982.         return self.tk.getint(self.tk.call(
  983.             self._w, 'index', index))
  984.     def insert(self, index, string):
  985.         self.tk.call(self._w, 'insert', index, string)
  986.     def scan_mark(self, x):
  987.         self.tk.call(self._w, 'scan', 'mark', x)
  988.     def scan_dragto(self, x):
  989.         self.tk.call(self._w, 'scan', 'dragto', x)
  990.     def select_adjust(self, index):
  991.         self.tk.call(self._w, 'select', 'adjust', index)
  992.     def select_clear(self):
  993.         self.tk.call(self._w, 'select', 'clear', 'end')
  994.     def select_from(self, index):
  995.         self.tk.call(self._w, 'select', 'set', index)
  996.     def select_present(self):
  997.         return self.tk.getboolean(
  998.             self.tk.call(self._w, 'select', 'present'))
  999.     def select_range(self, start, end):
  1000.         self.tk.call(self._w, 'select', 'range', start, end)
  1001.     def select_to(self, index):
  1002.         self.tk.call(self._w, 'select', 'to', index)
  1003.     def view(self, index):
  1004.         self.tk.call(self._w, 'view', index)
  1005.  
  1006. class Frame(Widget):
  1007.     def __init__(self, master=None, cnf={}, **kw):
  1008.         cnf = _cnfmerge((cnf, kw))
  1009.         extra = ()
  1010.         if cnf.has_key('class'):
  1011.             extra = ('-class', cnf['class'])
  1012.             del cnf['class']
  1013.         Widget.__init__(self, master, 'frame', cnf, {}, extra)
  1014.  
  1015. class Label(Widget):
  1016.     def __init__(self, master=None, cnf={}, **kw):
  1017.         Widget.__init__(self, master, 'label', cnf, kw)
  1018.  
  1019. class Listbox(Widget):
  1020.     def __init__(self, master=None, cnf={}, **kw):
  1021.         Widget.__init__(self, master, 'listbox', cnf, kw)
  1022.     def activate(self, index):
  1023.         self.tk.call(self._w, 'activate', index)
  1024.     def bbox(self, *args):
  1025.         return self._getints(self._do('bbox', args)) or None
  1026.     def curselection(self):
  1027.         # XXX Ought to apply self._getints()...
  1028.         return self.tk.splitlist(self.tk.call(
  1029.             self._w, 'curselection'))
  1030.     def delete(self, first, last=None):
  1031.         self.tk.call(self._w, 'delete', first, last)
  1032.     def get(self, first, last=None):
  1033.         if last:
  1034.             return self.tk.splitlist(self.tk.call(
  1035.                 self._w, 'get', first, last))
  1036.         else:
  1037.             return self.tk.call(self._w, 'get', first)
  1038.     def insert(self, index, *elements):
  1039.         apply(self.tk.call,
  1040.               (self._w, 'insert', index) + elements)
  1041.     def nearest(self, y):
  1042.         return self.tk.getint(self.tk.call(
  1043.             self._w, 'nearest', y))
  1044.     def scan_mark(self, x, y):
  1045.         self.tk.call(self._w, 'scan', 'mark', x, y)
  1046.     def scan_dragto(self, x, y):
  1047.         self.tk.call(self._w, 'scan', 'dragto', x, y)
  1048.     def see(self, index):
  1049.         self.tk.call(self._w, 'see', index)
  1050.     def index(self, index):
  1051.         i = self.tk.call(self._w, 'index', index)
  1052.         if i == 'none': return None
  1053.         return self.tk.getint(i)
  1054.     def select_adjust(self, index):
  1055.         self.tk.call(self._w, 'select', 'adjust', index)
  1056.     def select_anchor(self, index):
  1057.         self.tk.call(self._w, 'selection', 'anchor', index)
  1058.     def select_clear(self, first, last=None):
  1059.         self.tk.call(self._w,
  1060.                  'selection', 'clear', first, last)
  1061.     def select_includes(self, index):
  1062.         return self.tk.getboolean(self.tk.call(
  1063.             self._w, 'selection', 'includes', index))
  1064.     def select_set(self, first, last=None):
  1065.         self.tk.call(self._w, 'selection', 'set', first, last)
  1066.     def size(self):
  1067.         return self.tk.getint(self.tk.call(self._w, 'size'))
  1068.     def xview(self, *what):
  1069.         if not what:
  1070.             return self._getdoubles(self.tk.call(self._w, 'xview'))
  1071.         apply(self.tk.call, (self._w, 'xview')+what)
  1072.     def yview(self, *what):
  1073.         if not what:
  1074.             return self._getdoubles(self.tk.call(self._w, 'yview'))
  1075.         apply(self.tk.call, (self._w, 'yview')+what)
  1076.  
  1077. class Menu(Widget):
  1078.     def __init__(self, master=None, cnf={}, **kw):
  1079.         Widget.__init__(self, master, 'menu', cnf, kw)
  1080.     def tk_bindForTraversal(self):
  1081.         self.tk.call('tk_bindForTraversal', self._w)
  1082.     def tk_mbPost(self):
  1083.         self.tk.call('tk_mbPost', self._w)
  1084.     def tk_mbUnpost(self):
  1085.         self.tk.call('tk_mbUnpost')
  1086.     def tk_traverseToMenu(self, char):
  1087.         self.tk.call('tk_traverseToMenu', self._w, char)
  1088.     def tk_traverseWithinMenu(self, char):
  1089.         self.tk.call('tk_traverseWithinMenu', self._w, char)
  1090.     def tk_getMenuButtons(self):
  1091.         return self.tk.call('tk_getMenuButtons', self._w)
  1092.     def tk_nextMenu(self, count):
  1093.         self.tk.call('tk_nextMenu', count)
  1094.     def tk_nextMenuEntry(self, count):
  1095.         self.tk.call('tk_nextMenuEntry', count)
  1096.     def tk_invokeMenu(self):
  1097.         self.tk.call('tk_invokeMenu', self._w)
  1098.     def tk_firstMenu(self):
  1099.         self.tk.call('tk_firstMenu', self._w)
  1100.     def tk_mbButtonDown(self):
  1101.         self.tk.call('tk_mbButtonDown', self._w)
  1102.     def activate(self, index):
  1103.         self.tk.call(self._w, 'activate', index)
  1104.     def add(self, itemType, cnf={}, **kw):
  1105.         apply(self.tk.call, (self._w, 'add', itemType) 
  1106.               + self._options(cnf, kw))
  1107.     def add_cascade(self, cnf={}, **kw):
  1108.         self.add('cascade', cnf or kw)
  1109.     def add_checkbutton(self, cnf={}, **kw):
  1110.         self.add('checkbutton', cnf or kw)
  1111.     def add_command(self, cnf={}, **kw):
  1112.         self.add('command', cnf or kw)
  1113.     def add_radiobutton(self, cnf={}, **kw):
  1114.         self.add('radiobutton', cnf or kw)
  1115.     def add_separator(self, cnf={}, **kw):
  1116.         self.add('separator', cnf or kw)
  1117.     def delete(self, index1, index2=None):
  1118.         self.tk.call(self._w, 'delete', index1, index2)
  1119.     def entryconfig(self, index, cnf={}, **kw):
  1120.         apply(self.tk.call, (self._w, 'entryconfigure', index)
  1121.               + self._options(cnf, kw))
  1122.     def index(self, index):
  1123.         i = self.tk.call(self._w, 'index', index)
  1124.         if i == 'none': return None
  1125.         return self.tk.getint(i)
  1126.     def invoke(self, index):
  1127.         return self.tk.call(self._w, 'invoke', index)
  1128.     def post(self, x, y):
  1129.         self.tk.call(self._w, 'post', x, y)
  1130.     def unpost(self):
  1131.         self.tk.call(self._w, 'unpost')
  1132.     def yposition(self, index):
  1133.         return self.tk.getint(self.tk.call(
  1134.             self._w, 'yposition', index))
  1135.  
  1136. class Menubutton(Widget):
  1137.     def __init__(self, master=None, cnf={}, **kw):
  1138.         Widget.__init__(self, master, 'menubutton', cnf, kw)
  1139.  
  1140. class Message(Widget):
  1141.     def __init__(self, master=None, cnf={}, **kw):
  1142.         Widget.__init__(self, master, 'message', cnf, kw)
  1143.  
  1144. class Radiobutton(Widget):
  1145.     def __init__(self, master=None, cnf={}, **kw):
  1146.         Widget.__init__(self, master, 'radiobutton', cnf, kw)
  1147.     def deselect(self):
  1148.         self.tk.call(self._w, 'deselect')
  1149.     def flash(self):
  1150.         self.tk.call(self._w, 'flash')
  1151.     def invoke(self):
  1152.         self.tk.call(self._w, 'invoke')
  1153.     def select(self):
  1154.         self.tk.call(self._w, 'select')
  1155.  
  1156. class Scale(Widget):
  1157.     def __init__(self, master=None, cnf={}, **kw):
  1158.         Widget.__init__(self, master, 'scale', cnf, kw)
  1159.     def get(self):
  1160.         return self.tk.getint(self.tk.call(self._w, 'get'))
  1161.     def set(self, value):
  1162.         self.tk.call(self._w, 'set', value)
  1163.  
  1164. class Scrollbar(Widget):
  1165.     def __init__(self, master=None, cnf={}, **kw):
  1166.         Widget.__init__(self, master, 'scrollbar', cnf, kw)
  1167.     def activate(self, index):
  1168.         self.tk.call(self._w, 'activate', index)
  1169.     def delta(self, deltax, deltay):
  1170.         return self.getdouble(self.tk.call(
  1171.             self._w, 'delta', deltax, deltay))
  1172.     def fraction(self, x, y):
  1173.         return self.getdouble(self.tk.call(
  1174.             self._w, 'fraction', x, y))
  1175.     def identify(self, x, y):
  1176.         return self.tk.call(self._w, 'identify', x, y)
  1177.     def get(self):
  1178.         return self._getdoubles(self.tk.call(self._w, 'get'))
  1179.     def set(self, *args):
  1180.         apply(self.tk.call, (self._w, 'set')+args)
  1181.  
  1182. class Text(Widget):
  1183.     def __init__(self, master=None, cnf={}, **kw):
  1184.         Widget.__init__(self, master, 'text', cnf, kw)
  1185.         self.bind('<Delete>', self.bspace)
  1186.     def bspace(self, *args):
  1187.         self.delete('insert')
  1188.     def tk_textSelectTo(self, index):
  1189.         self.tk.call('tk_textSelectTo', self._w, index)
  1190.     def tk_textBackspace(self):
  1191.         self.tk.call('tk_textBackspace', self._w)
  1192.     def tk_textIndexCloser(self, a, b, c):
  1193.         self.tk.call('tk_textIndexCloser', self._w, a, b, c)
  1194.     def tk_textResetAnchor(self, index):
  1195.         self.tk.call('tk_textResetAnchor', self._w, index)
  1196.     def compare(self, index1, op, index2):
  1197.         return self.tk.getboolean(self.tk.call(
  1198.             self._w, 'compare', index1, op, index2))
  1199.     def debug(self, boolean=None):
  1200.         return self.tk.getboolean(self.tk.call(
  1201.             self._w, 'debug', boolean))
  1202.     def delete(self, index1, index2=None):
  1203.         self.tk.call(self._w, 'delete', index1, index2)
  1204.     def dlineinfo(self, index):
  1205.         return self._getints(self.tk.call(self._w, 'dlineinfo', index))
  1206.     def get(self, index1, index2=None):
  1207.         return self.tk.call(self._w, 'get', index1, index2)
  1208.     def index(self, index):
  1209.         return self.tk.call(self._w, 'index', index)
  1210.     def insert(self, index, chars, *args):
  1211.         apply(self.tk.call, (self._w, 'insert', index, chars)+args)
  1212.     def mark_names(self):
  1213.         return self.tk.splitlist(self.tk.call(
  1214.             self._w, 'mark', 'names'))
  1215.     def mark_set(self, markName, index):
  1216.         self.tk.call(self._w, 'mark', 'set', markName, index)
  1217.     def mark_unset(self, markNames):
  1218.         apply(self.tk.call, (self._w, 'mark', 'unset') + markNames)
  1219.     def scan_mark(self, y):
  1220.         self.tk.call(self._w, 'scan', 'mark', y)
  1221.     def scan_dragto(self, y):
  1222.         self.tk.call(self._w, 'scan', 'dragto', y)
  1223.     def search(self, pattern, index, stopindex=None,
  1224.            forwards=None, backwards=None, exact=None,
  1225.            regexp=None, nocase=None, count=None):
  1226.         args = [self._w, 'search']
  1227.         if forwards: args.append('-forwards')
  1228.         if backwards: args.append('-backwards')
  1229.         if exact: args.append('-exact')
  1230.         if regexp: args.append('-regexp')
  1231.         if nocase: args.append('-nocase')
  1232.         if count: args.append('-count'); args.append(count)
  1233.         if pattern[0] == '-': args.append('--')
  1234.         args.append(pattern)
  1235.         args.append(index)
  1236.         if stopindex: args.append(stopindex)
  1237.         return apply(self.tk.call, tuple(args))
  1238.     def see(self, index):
  1239.         self.tk.call(self._w, 'see', index)
  1240.     def tag_add(self, tagName, index1, index2=None):
  1241.         self.tk.call(
  1242.             self._w, 'tag', 'add', tagName, index1, index2)
  1243.     def tag_unbind(self, tagName, sequence):
  1244.         self.tk.call(self._w, 'tag', 'bind', tagName, sequence, '')
  1245.     def tag_bind(self, tagName, sequence, func, add='', brk=''):
  1246.         if add: add='+'
  1247.         name = self._register(func, self._substitute)
  1248.         self.tk.call(self._w, 'tag', 'bind', 
  1249.                  tagName, sequence, 
  1250.                  (add + name,) + self._subst_format)
  1251.         if brk:
  1252.             self.tk.call(self._w, 'tag', 'bind',
  1253.                      tagName, sequence,
  1254.                      "+break")
  1255.     def tag_config(self, tagName, cnf={}, **kw):
  1256.         apply(self.tk.call, 
  1257.               (self._w, 'tag', 'configure', tagName)
  1258.               + self._options(cnf, kw))
  1259.     def tag_delete(self, *tagNames):
  1260.         apply(self.tk.call, (self._w, 'tag', 'delete') + tagNames)
  1261.     def tag_lower(self, tagName, belowThis=None):
  1262.         self.tk.call(self._w, 'tag', 'lower', tagName, belowThis)
  1263.     def tag_names(self, index=None):
  1264.         return self.tk.splitlist(
  1265.             self.tk.call(self._w, 'tag', 'names', index))
  1266.     def tag_nextrange(self, tagName, index1, index2=None):
  1267.         return self.tk.splitlist(self.tk.call(
  1268.             self._w, 'tag', 'nextrange', tagName, index1, index2))
  1269.     def tag_raise(self, tagName, aboveThis=None):
  1270.         self.tk.call(
  1271.             self._w, 'tag', 'raise', tagName, aboveThis)
  1272.     def tag_ranges(self, tagName):
  1273.         return self.tk.splitlist(self.tk.call(
  1274.             self._w, 'tag', 'ranges', tagName))
  1275.     def tag_remove(self, tagName, index1, index2=None):
  1276.         self.tk.call(
  1277.             self._w, 'tag', 'remove', tagName, index1, index2)
  1278.     def window_cget(self, index, option):
  1279.         return self.tk.call(self._w, 'window', 'cget', index, option)
  1280.     def window_config(self, index, cnf={}, **kw):
  1281.         apply(self.tk.call, 
  1282.               (self._w, 'window', 'configure', index)
  1283.               + self._options(cnf, kw))
  1284.     def window_create(self, index, cnf={}, **kw):
  1285.         apply(self.tk.call, 
  1286.               (self._w, 'window', 'create', index)
  1287.               + self._options(cnf, kw))
  1288.     def window_names(self):
  1289.         return self.tk.splitlist(
  1290.             self.tk.call(self._w, 'window', 'names'))
  1291.     def xview(self, *what):
  1292.         if not what:
  1293.             return self._getdoubles(self.tk.call(self._w, 'xview'))
  1294.         apply(self.tk.call, (self._w, 'xview')+what)
  1295.     def yview(self, *what):
  1296.         if not what:
  1297.             return self._getdoubles(self.tk.call(self._w, 'yview'))
  1298.         apply(self.tk.call, (self._w, 'yview')+what)
  1299.     def yview_pickplace(self, *what):
  1300.         apply(self.tk.call, (self._w, 'yview', '-pickplace')+what)
  1301.  
  1302. class OptionMenu(Widget):
  1303.     def __init__(self, master, variable, value, *values):
  1304.         self.widgetName = 'tk_optionMenu'
  1305.         Widget._setup(self, master, {})
  1306.         self.menuname = apply(
  1307.             self.tk.call,
  1308.             (self.widgetName, self._w, variable, value) + values)
  1309.  
  1310. class Image:
  1311.     def __init__(self, imgtype, name=None, cnf={}, **kw):
  1312.         self.name = None
  1313.         master = _default_root
  1314.         if not master: raise RuntimeError, 'Too early to create image'
  1315.         self.tk = master.tk
  1316.         if not name: name = `id(self)`
  1317.         if kw and cnf: cnf = _cnfmerge((cnf, kw))
  1318.         elif kw: cnf = kw
  1319.         options = ()
  1320.         for k, v in cnf.items():
  1321.             if callable(v):
  1322.                 v = self._register(v)
  1323.             options = options + ('-'+k, v)
  1324.         apply(self.tk.call,
  1325.               ('image', 'create', imgtype, name,) + options)
  1326.         self.name = name
  1327.     def __str__(self): return self.name
  1328.     def __del__(self):
  1329.         if self.name:
  1330.             self.tk.call('image', 'delete', self.name)
  1331.     def __setitem__(self, key, value):
  1332.         self.tk.call(self.name, 'configure', '-'+key, value)
  1333.     def __getitem__(self, key):
  1334.         return self.tk.call(self.name, 'configure', '-'+key)
  1335.     def height(self):
  1336.         return self.tk.getint(
  1337.             self.tk.call('image', 'height', self.name))
  1338.     def type(self):
  1339.         return self.tk.call('image', 'type', self.name)
  1340.     def width(self):
  1341.         return self.tk.getint(
  1342.             self.tk.call('image', 'width', self.name))
  1343.  
  1344. class PhotoImage(Image):
  1345.     def __init__(self, name=None, cnf={}, **kw):
  1346.         apply(Image.__init__, (self, 'photo', name, cnf), kw)
  1347.     def blank(self):
  1348.         self.tk.call(self.name, 'blank')
  1349.     def cget(self):
  1350.         return self.tk.call(self.name, 'cget')
  1351.     # XXX config
  1352.     def __getitem__(self, key):
  1353.         return self.tk.call(self.name, 'cget', '-' + key)
  1354.     def copy(self):
  1355.         destImage = PhotoImage()
  1356.         self.tk.call(destImage, 'copy', self.name)
  1357.         return destImage
  1358.     def zoom(self,x,y=''):
  1359.         destImage = PhotoImage()
  1360.         if y=='': y=x
  1361.         self.tk.call(destImage, 'copy', self.name, '-zoom',x,y)
  1362.         return destImage
  1363.     def subsample(self,x,y=''):
  1364.         destImage = PhotoImage()
  1365.         if y=='': y=x
  1366.         self.tk.call(destImage, 'copy', self.name, '-subsample',x,y)
  1367.         return destImage
  1368.     def get(self, x, y):
  1369.         return self.tk.call(self.name, 'get', x, y)
  1370.     def put(self, data, to=None):
  1371.         args = (self.name, 'put', data)
  1372.         if to:
  1373.             args = args + to
  1374.         apply(self.tk.call, args)
  1375.     # XXX read
  1376.     # XXX write
  1377.  
  1378. class BitmapImage(Image):
  1379.     def __init__(self, name=None, cnf={}, **kw):
  1380.         apply(Image.__init__, (self, 'bitmap', name, cnf), kw)
  1381.  
  1382. def image_names(): return _default_root.tk.call('image', 'names')
  1383. def image_types(): return _default_root.tk.call('image', 'types')
  1384.  
  1385. ######################################################################
  1386. # Extensions:
  1387.  
  1388. class Studbutton(Button):
  1389.     def __init__(self, master=None, cnf={}, **kw):
  1390.         Widget.__init__(self, master, 'studbutton', cnf, kw)
  1391.         self.bind('<Any-Enter>',       self.tkButtonEnter)
  1392.         self.bind('<Any-Leave>',       self.tkButtonLeave)
  1393.         self.bind('<1>',               self.tkButtonDown)
  1394.         self.bind('<ButtonRelease-1>', self.tkButtonUp)
  1395.  
  1396. class Tributton(Button):
  1397.     def __init__(self, master=None, cnf={}, **kw):
  1398.         Widget.__init__(self, master, 'tributton', cnf, kw)
  1399.         self.bind('<Any-Enter>',       self.tkButtonEnter)
  1400.         self.bind('<Any-Leave>',       self.tkButtonLeave)
  1401.         self.bind('<1>',               self.tkButtonDown)
  1402.         self.bind('<ButtonRelease-1>', self.tkButtonUp)
  1403.         self['fg']               = self['bg']
  1404.         self['activebackground'] = self['bg']
  1405.  
  1406.  
  1407. # Emacs cruft
  1408. # Local Variables:
  1409. # py-indent-offset: 8
  1410. # End:
  1411.